package Datastruct.stack;

public class TestArrayStack {
    public static void main(String[] args) {

//        System.out.println(detecation("aabbaa"));

        String str="3+3*2-2";

        /**
         * 1.需要遍历字符串，获取每一个字符
         * 2.判断当前字符是一个运算符还是一个数字
         * 3.把数字存放在数字栈中，把运算符放在运算符栈
         * 4.运算符栈：  如果是一个空栈，那么直接运算符入栈，如果运算符栈中已经有其他运算符
         * 就需要先对比运算符的优先级，新进来的运算符如果小于等于原栈中的运算符，那么需要把
         * 原运算符栈弹出来，数字栈中的数字进行弹栈，进行运算，运算后的结果重新放入数字栈中，新运算符入栈
         */

        //创建数字栈
        ArrayStack numstack=new ArrayStack(10);
        ArrayStack charstack=new ArrayStack(10);

        int length = str.length();
        int temp1=0;
        int temp2=0;
        char symbolchar=0;
        int result=0;
       String values="";

        for(int i=0;i<length;i++){
            //获取每一个字符
            char c=str.charAt(i);
            //判断当前数字是否是字符
            if(charstack.isOper(c)){
                //判断字符栈是否为空
                if(!charstack.isEmpty()){
                    //判断当前运算符的优先级  小于或等于字符栈中的优先级，就先运算
                    if(charstack.priority(c)<=charstack.priority((char) charstack.peek())){
                            temp1=numstack.pop();
                            temp2=numstack.pop();

                            symbolchar= (char) charstack.pop();
                         result= numstack.calculate(temp1,temp2,symbolchar);

                            //计算结果放入数字栈
                           numstack.push(result);
                           //当前操作符入栈
                        charstack.push(c);
                    }else {
                        //当前运算符优先级大于栈中优先级 直接入栈
                        charstack.push(c);
                    }


                }else{
                    //当前字符栈为空直接入栈
                    charstack.push(c);
                }
            }else {
                //当前字符是数字       33+44
                values+=c;
                if(i==length-1){
                    numstack.push(Integer.parseInt(values));
                }else {
                    char data=str.substring(i+1,i+2).charAt(0);
                    if(charstack.isOper(data)){
                        numstack.push(Integer.parseInt(values));
                        values="";
                    }
                }

            }
        }
        while (true){
            if(charstack.isEmpty()){
                break;
            }

            temp1=numstack.pop();
            temp2=numstack.pop();
            symbolchar= (char) charstack.pop();
            result=numstack.calculate(temp1,temp2,symbolchar);
            numstack.push(result);

        }
        int res=numstack.pop();

        System.out.println("计算结果是："+res);

    }

    //判断栈是否为回文   正着读和反着读是一样的aba  abba
    public  static  boolean detecation(String str){
        //初始化栈
        ArrayStack arrayStack=new ArrayStack(10);

        //
        int length = str.length();
        //入栈
        for(int i=0;i<length;i++){
            arrayStack.push(str.charAt(i));
        }


        //拼接新的字符串
        String newstr="";
        int length1 = arrayStack.length();
        for(int i=0;i<length1;i++){
            //判断栈是否为空
            if(!arrayStack.isEmpty()){
                char value = (char) arrayStack.pop();
                newstr=newstr+value;

            }
        }
        //判断是否是回文
        if(str.equals(newstr)){
            return true;

        }
        return false;
    }

}
